home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / Source / GENetReleaseƒ / GETest / SynchGraphic.c next >
Text File  |  1994-03-08  |  7KB  |  335 lines
  1. /*
  2.     SynchGraphic.c
  3.     
  4.     Graphics for Graphic Elements SynchTest
  5.     
  6.     1/29/94
  7.     
  8.     Al Evans
  9.     
  10. */
  11.  
  12. #include "SynchGraphic.h"
  13. #include "Motion.h"
  14.  
  15. short    objUpdateIntrvl;
  16. short    objMoveDist;
  17. Boolean    objLinearMotion;
  18. Boolean objCollision;
  19. short    objSeparation;
  20. short    numObjs;
  21.  
  22. short RangedRdm(short min, short max)
  23. {
  24.     short rdm;
  25.     
  26.     rdm = Random();
  27.     if (rdm < 0) 
  28.         rdm = -rdm;
  29.     rdm = rdm % (max - min);
  30.     rdm += min;
  31.     return rdm;
  32. }
  33.  
  34.  
  35. GrafElPtr MakeAnObject(GEWorldPtr world, OSType id)
  36. {
  37.     GrafElPtr anObject;
  38.     
  39.     anObject = FindElementByID(world, id);
  40.     if (anObject == nil) {
  41.         anObject = NewBasicPICT(world, id, testObjPlane, rTestObj, transparent, 0, 0);
  42.         if (anObject == nil) return nil;
  43.     }
  44.     SetElementPlane(world, anObject->objectID, testObjPlane);
  45.     if (objLinearMotion) {
  46.         SetAutoChange(world, id, DoObjectLinear, nil, objUpdateIntrvl);
  47.         SetCollision(world, id, nil, 0);
  48.     }
  49.     else {
  50.         SetAutoChange(world, id, DoObjectRandom, nil, objUpdateIntrvl);
  51.     }
  52.     
  53.     return anObject;
  54. }
  55.  
  56. Boolean InitObjectGraphics(GEWorldPtr world)
  57. {
  58.     GrafElPtr        thisElement;
  59.     
  60.     objUpdateIntrvl = 33;
  61.     objMoveDist = 4;
  62.     objSeparation = 4;
  63.     objLinearMotion = true;
  64.     objCollision = false;
  65.     thisElement = MakeAnObject(world, firstObjID);
  66.     if (thisElement == nil) return false;
  67.     ShowElement(world, firstObjID, false);
  68. }
  69.  
  70. void HideObjects(GEWorldPtr world)
  71. {
  72.     GrafElPtr    thisObj;
  73.     OSType        objID = firstObjID;
  74.     
  75.     while (thisObj = FindElementByID(world, objID)){
  76.         ShowElement(world, objID, false);
  77.         objID++;
  78.     }
  79. }
  80.  
  81. short GetMoveDistance(void)
  82. {
  83.     return objMoveDist;
  84. }
  85.  
  86. Boolean MotionIsLinear(void)
  87. {
  88.     return objLinearMotion;
  89. }
  90.  
  91. void SetObjMotionLinear(Boolean linearMotion)
  92. {
  93.     objLinearMotion = linearMotion;
  94. }
  95.  
  96. Boolean ObjCollisionActive(void)
  97. {
  98.     return objCollision;
  99. }
  100.  
  101. void SetObjCollision(GEWorldPtr world, Boolean collide)
  102. {
  103.     OSType        objID = firstObjID;
  104.     GrafElPtr    anObject;
  105.  
  106.     if (objLinearMotion) return; //no collision possible
  107.     
  108.     objCollision = collide;
  109.     while (anObject = FindElementByID(world, objID)){
  110.         if (objCollision)
  111.             SetCollision(world, objID, DoObjectCollide, testObjPlane);
  112.         else
  113.             SetCollision(world, objID, nil, 0);
  114.         objID++;
  115.     }
  116. }
  117.  
  118. void SetMoveDistance(GEWorldPtr world, short newMove)
  119. {
  120.     OSType        objID = firstObjID;
  121.     GrafElPtr    anObject;
  122.     short        objMove;
  123.     
  124.     objMoveDist = newMove;
  125.     
  126.     while (anObject = FindElementByID(world, objID)){
  127.         if (objLinearMotion) {
  128.         objMove = (short) ((long) anObject->changeData);
  129.         if (objMove >= 0)
  130.             objMove = newMove;
  131.         else
  132.             objMove = -newMove;
  133.         anObject->changeData = (Ptr) ((long) objMove);
  134.         }
  135.         else {
  136.             anObject->changeData = (Ptr) ((long) RangedRdm(1, 2 * objMoveDist) << 16) + RangedRdm(1, 2 * objMoveDist);
  137.         }
  138.         objID++;
  139.     }
  140. }
  141.  
  142. short GetUpdateInterval(void)
  143. {
  144.     return objUpdateIntrvl;
  145. }
  146. void SetUpdateInterval(GEWorldPtr world, short newInterval)
  147. {
  148.     OSType        objID = firstObjID;
  149.     GrafElPtr    anObject;
  150.     
  151.     objUpdateIntrvl = newInterval;
  152.     while (anObject = FindElementByID(world, objID)){
  153.         anObject->changeIntrvl = newInterval;
  154.         objID++;
  155.     }
  156. }
  157.  
  158. short GetNumberOfObjects(void)
  159. {
  160.     return numObjs;
  161. }
  162.  
  163. void SetNumberOfObjects(GEWorldPtr world, short newNumber)
  164. {
  165.     OSType        objID = firstObjID;
  166.     GrafElPtr    anObject;
  167.     Rect        objRect;
  168.     short        objCount;
  169.     short        hOffset, vOffset;
  170.     
  171.     numObjs = newNumber;
  172.     HideObjects(world);
  173.     anObject = MakeAnObject(world, objID);
  174.     objRect = anObject->animationRect;
  175.     RectOffset(&objRect, -objRect.left + 4, -objRect.top + 16);
  176.     hOffset = objRect.right - objRect.left + objSeparation;
  177.     vOffset = objRect.bottom -objRect.top + objSeparation;
  178.     if (objLinearMotion) {
  179.         for (objCount = 0; objCount < newNumber; objCount++) {
  180.             anObject= MakeAnObject(world, objID);
  181.             if (anObject == nil) return;
  182.             MoveElementTo(world, anObject->objectID, objRect.left, objRect.top);
  183.             anObject->changeData = (Ptr) ((long) objMoveDist);
  184.             ShowElement(world, anObject->objectID, true);
  185.             RectOffset(&objRect, hOffset, 0);
  186.             if (objRect.right > world->animationRect.right) 
  187.                 RectOffset(&objRect, -objRect.left + 4, vOffset);
  188.             objID++;
  189.         }
  190.     }
  191.     else {
  192.         for (objCount = 0; objCount < newNumber; objCount++) {
  193.             anObject= MakeAnObject(world, objID);
  194.             if (anObject == nil) return;
  195.             MoveElementTo(world, anObject->objectID, 
  196.                 RangedRdm(4, world->animationRect.right - hOffset), 
  197.                 RangedRdm(16, world->animationRect.bottom - vOffset));
  198.             anObject->changeData = (Ptr) ((long) RangedRdm(1, 2 * objMoveDist) << 16) + RangedRdm(1, 2 * objMoveDist);
  199.             ShowElement(world, anObject->objectID, true);
  200.             objID++;
  201.         }
  202.     }
  203.     
  204. }
  205.  
  206. short GetObjSeparation(void)
  207. {
  208.     return objSeparation;
  209. }
  210.  
  211. void SetObjSeparation(GEWorldPtr world, short newSeparation)
  212. {
  213. #pragma unused(world)
  214.     objSeparation = newSeparation;
  215. }
  216.  
  217.  
  218. pascal void DoObjectLinear(GEWorldPtr world, GrafElPtr obj)
  219. {
  220.     GEDirection    collisionDir;
  221.     short currXMove = (short) ((long) obj->changeData);
  222.     short currYMove = 0;
  223.     register Rect *objRect = &obj->animationRect;
  224.     
  225.     collisionDir = CheckLimits(objRect, &world->animationRect);
  226.     switch (collisionDir) {
  227.         case right:
  228.         case left:
  229.             obj->changeData = (Ptr) ((long) -currXMove);
  230.             currXMove = -currXMove;
  231.             currYMove = (objRect->bottom - objRect->top + objSeparation) >> 2;
  232.             if (collisionDir == right) {
  233.                 currXMove -= objRect->right - world->animationRect.right;
  234.                 SetElementPlane(world, obj->objectID, testObjPlane + 1);
  235.             }
  236.             else {
  237.                 currXMove += world->animationRect.left - objRect->left;
  238.                 SetElementPlane(world, obj->objectID, testObjPlane);
  239.             }
  240.             break;
  241.         case down:
  242.             PtrMoveElementTo(world, obj, 4, 16);
  243.             return;
  244.     }
  245.     PtrMoveElement(world, obj, currXMove, currYMove);        
  246. }
  247.  
  248. void BounceObj(GEDirection direction, short *xMove, short *yMove)
  249. {
  250.     switch (direction) {
  251.         case right:
  252.             if (*xMove > 0);
  253.                 *xMove = -*xMove;
  254.             break;
  255.         case left:
  256.             if (*xMove < 0);
  257.                 *xMove = -*xMove;
  258.             break;
  259.         case up:
  260.             if (*yMove < 0)
  261.                 *yMove = -*yMove;
  262.             break;
  263.         case down:
  264.             if (*yMove > 0)
  265.                 *yMove = -*yMove;
  266.             break;
  267.     }
  268. }
  269.  
  270. pascal void DoObjectRandom(GEWorldPtr world, GrafElPtr obj)
  271. {
  272.     GEDirection collisionDir;
  273.     register short *currXMove = (short *) &obj->changeData + 1;
  274.     register short *currYMove = (short *) &obj->changeData;
  275.     
  276.     collisionDir = CheckLimits(&obj->animationRect, &world->animationRect);
  277.     if (collisionDir != none)
  278.         BounceObj(collisionDir, currXMove, currYMove);
  279.     PtrMoveElement(world, obj, *currXMove, *currYMove);
  280.     
  281. }
  282.  
  283. pascal void DoObjectCollide(GEWorldPtr world, GrafElPtr obj, GEDirection dir, GrafElPtr objHit)
  284. {
  285. #pragma unused (world, objHit)
  286.  
  287.     register short *currXMove = (short *) &obj->changeData + 1;
  288.     register short *currYMove = (short *) &obj->changeData;
  289.     
  290.     
  291.     switch (dir) {
  292.         case left:
  293.             if (*currXMove < 0)
  294.                 *currXMove = -*currXMove;
  295.             break;
  296.         case right:
  297.             if (*currXMove > 0)
  298.                 *currXMove = -*currXMove;
  299.             break;
  300.         case up:
  301.             if (*currYMove < 0)
  302.                 *currYMove = -*currYMove;
  303.             break;
  304.         case down:
  305.             if (*currYMove > 0)
  306.                 *currYMove = -*currYMove;
  307.             break;
  308.         case upLeft:
  309.             if (*currYMove < 0)
  310.                 *currYMove = -*currYMove;
  311.             if (*currXMove < 0)
  312.                 *currXMove = -*currXMove;
  313.             break;
  314.         case upRight:
  315.             if (*currYMove < 0)
  316.                 *currYMove = -*currYMove;
  317.             if (*currXMove > 0)
  318.                 *currXMove = -*currXMove;
  319.             break;
  320.         case downLeft:
  321.             if (*currYMove > 0)
  322.                 *currYMove = -*currYMove;
  323.             if (*currXMove < 0)
  324.                 *currXMove = -*currXMove;
  325.             break;
  326.         
  327.         case downRight:
  328.             if (*currYMove > 0)
  329.                 *currYMove = -*currYMove;
  330.             if (*currXMove > 0)
  331.                 *currXMove = -*currXMove;
  332.             break;
  333.     }
  334. }
  335.